package com.cn.dim.controller;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.cn.dim.pojo.Pages;
import com.cn.dim.service.ChkcountService;
import com.github.pagehelper.Page;


@Controller
@RequestMapping("/chkcount")
public class ChkcountController {

	@Resource
	private ChkcountService chkcountService;
	@RequestMapping(value ="/queryChkcount",method = RequestMethod.GET)
	@ResponseBody
	//主方法1，由页面传来的巡查点下拉框中的参数决定是查全部检查点，还是单一检查点；
	public Map<String,Object> queryChkcount(HttpServletRequest request,Pages pages,String stime,String etime,String chkpointid){
		Map<String,Object> t_Map=new HashMap<>();//定义空参数
		Map<String,Object> re_Map=new HashMap<>();//定义大返回值
 		List<Map<String,Object>> re_List = new ArrayList<>();//定义表格数据集
//情况1：stime（""）    etime（""）  chkpointid（""）
		//如果参数都是空，表示查询所有记录，需要先取得巡查点的id集合，然后循环集合，从而获取每个巡查点的数据（如果没有数据则不显示）有的话则取到stime（后缀置为“ 00:00:00”），
		//etime则取今天（后缀置为“ 23:59:59”），然后调用queryChkcountOne函数（传入上述3个参数）
 		if(stime==null){stime="";}
 		if(etime==null){etime="";}
 		if(chkpointid==null){chkpointid="";}
		if(stime.equals("")&&etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
//情况2：stime（""）    etime（√）  chkpointid（""）
		if(stime.equals("")&&!etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
//情况3：stime（""）    etime（""）  chkpointid（√）
		if(stime.equals("")&&etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){//由于chkpointid给定，这里只有1条记录
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
//情况4：stime（""）    etime（√）  chkpointid（√）
		if(stime.equals("")&&!etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：取得该巡查点最早的那条巡查记录
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String p_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况5：stime（√）    etime（""）  chkpointid（""）
		if(!stime.equals("")&&etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况6：stime（√）    etime（""）  chkpointid（√）
		if(!stime.equals("")&&etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=getCdate();
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况7：stime（√）    etime（√）  chkpointid（""）
		if(!stime.equals("")&&!etime.equals("")&&chkpointid.equals(""))
		{
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}

//情况8：stime（√）    etime（√）  chkpointid（√）
		if(!stime.equals("")&&!etime.equals("")&&!chkpointid.equals(""))
		{
			t_Map.put("chkpointid", chkpointid);
			List<Map<String,Object>> m_chkpointids = chkcountService.queryChkpoint(t_Map);
			for(Map m:m_chkpointids){
				//第一步：取得巡查点id
				String cpid=(String)m.get("id");//逐条取得巡查点id
				String cpname=(String)m.get("chkpointname");//逐条取得巡查点名称
				//第二步：开始时间取参数（开始时间如果要早于该节点最早的那条记录，则开始时间取最早的那条记录的时间），截止时间取今天；
				Map<String,Object> tmm=new HashMap<>();//定义参数
				tmm.put("chkpointid", cpid);
				List<Map<String,Object>> sts = chkcountService.getStime(tmm);
				if(sts.size()==0)//如果没有改巡查点的数据则进入下一个巡查点
				{
					continue;
				}
				String t_stime=((String)(sts.get(0).get("chktime"))).substring(0, 10)+" 00:00:00";
				String p_stime=stime+" 00:00:00";
				if(isPastDate(t_stime,p_stime ))//如果选择的开始时间要比实际记录中的第一条记录要早，则将stime赋值为第一条记录的那个时间；
				{
					p_stime=t_stime;//将第一条记录的值赋值给stime
				}
				String p_etime=etime+" 23:59:59";
				if(isPastDate(p_stime, p_etime))//如果截止时间要早于开始时间，也不产生记录
				{
					continue;
				}
				//第三步：取得该巡查点的统计数据
				Map<String,Object> m_chkcountOne=queryChkcountOne(p_stime,p_etime,cpid);
				m_chkcountOne.put("chkpointname", cpname);
				//第四步：将构造好的行记录map保存到list中
				re_List.add(m_chkcountOne);
			}
		}
		
		re_Map.put("rows", re_List);

		return re_Map;
	}
	
    
	//主方法2，对单一检查点进行统计汇总，再拼成map格式的list，参数是页面的查询条件
	public Map<String,Object> queryChkcountOne(String stime,String etime,String chkpointid){
		Map<String,Object> param=new HashMap<>();//定义查询参数
		Map<String,Object> reMap=new HashMap<>();//定义返回值
		//当参数都存在并且有效时
		//1：取该巡查点定义的每日巡查次数，进而计算出该时间段内的规定巡查次数；
		param.put("chkpointid", chkpointid);
		List<Map<String,Object>> list_defTime=chkcountService.queryDefTime(param);
		
		int defNum=Integer.parseInt((String)(list_defTime.get(0).get("timesineveryday")));
		int days=getDayNum(stime,etime);
		int allDefNum=defNum*days;
		reMap.put("allDefNum", allDefNum);
		
		//2：取得该巡查点，该时间段内的实际巡查次数；
		param.put("stime", stime);
		param.put("etime", etime);
		int realNum=chkcountService.queryReaTime(param);
		reMap.put("realNum", realNum);
		
		//3：取得该巡查点，该时间段内的结果正常的次数；
		int okNum=chkcountService.queryOkTime(param);
		reMap.put("okNum", okNum);
		
		//4：取得该巡查点，该时间段内的结果异常的次数；
		int errNum=chkcountService.queryErrTime(param);
		reMap.put("errNum", errNum);
		
		return reMap;
	}
	
    /**
	 * 作用： 适用于只选择了截止时间，如果截止时间要早于计算出的开始时间，则不产生记录；
	 * 参数：页面带过来的开始日期（stime必须在调用前判断为有效的时间字符串，格式为yyyy-MM-dd HH:mm:ss）
	 * 更新时间：2018-12-29
	 */
    public boolean isPastDate(String stime,String etime)
    {
        boolean flag = false;
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try 
		{
			Date sDate = sdf.parse(stime);
			Date eDate = sdf.parse(etime);
			flag = eDate.before(sDate);
		} 
		catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        return flag;
    }
    
    /**
	 * 作用：获取当前日期的yyyy-MM-dd 23:59:59格式字符串
	 * 参数：
	 * 更新时间：
	 */
    public String getCdate()
    {
    	String cdate_s="";
    	try 
		{
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			cdate_s = sdf.format(new Date());
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
    	return cdate_s+" 23:59:59";
    }
    
    /**
	 * 作用：获取两个时间之间的天数，如果是同一日期，则认为是1
	 * 参数：开始时间与截止时间
	 * 更新时间：
	 */
    public int getDayNum(String stime,String etime)
    {
        int timeDistance = 0 ;
    	try 
		{
			SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			Date st=sdf.parse(stime);
			Date et=sdf.parse(etime);

	        Calendar c_st=Calendar.getInstance();
	        c_st.setTime(st);
	        
	        Calendar c_et=Calendar.getInstance();
	        c_et.setTime(et);
		
	    	int day_st=c_st.get(Calendar.DAY_OF_YEAR);
	        int day_et=c_et.get(Calendar.DAY_OF_YEAR);
	        
	        int year_st=c_st.get(Calendar.YEAR);
	        int year_et=c_et.get(Calendar.YEAR);
	        if(year_st != year_et) //不在同一年
	        {
	            for(int i = year_st ; i < year_et ; i ++)
	            {
	                if(i%4==0 && i%100!=0 || i%400==0)    //闰年            
	                {
	                    timeDistance+=366;
	                }
	                else    //不是闰年
	                {
	                    timeDistance+=365;
	                }
	            }
	            timeDistance=timeDistance+(day_et-day_st) ;
	        }
	        else//同年
	        {
	            timeDistance=day_et-day_st;
	        }
		}
    	catch (Exception e)
    	{
			// TODO: handle exception
			e.printStackTrace();
		}
    	return timeDistance+1;
    }
}
